Shiny é um pacote do R (também disponível para o Python) que permite a criação e publicação de aplicações web sem necessidade de conhecimento prévio em HTML, CSS e JavaScript;
O processo necessário para criação dessas aplicações seja bastante facilitado para usuários do R.
Em essência, um App Shiny é gerado a partir de dois objetos e a chamada de uma função:
UI (Interface do Usuário)
Server
Função shinyApp(ui, server)
O objeto UI é geralmente inicializado pela função fluidPage(), que gerá uma página HTML vazia (também podem ser usadas outras funções para inicializar o UI);
São definidos os tipos de inputs (valores de entrada) e outputs (valores de saída) que o App Shiny apresentará, assim como também a formatação, layout.
Há inúmeros tipos de input disponíveis no Shiny, de todo modo, para que sejam reconhecidos e processados, todos ele precisam de dois parâmetros em comum:
Parâmetro “inputId”: Trata-se de uma string simples e única que será armazenada dentro da lista “input” que é parâmetro da função server(input, output). Desse modo, deve-se utilizar id´s diferentes para referenciar diferentes inputs;
Parâmetro “label”: Trata-se do rótulo/mensagem/instrução que irá aparecer no App Shiny, orientando o usuário sobre como ele deve interagir com as opções de input dadas.
Dada uma listagem de opções fornecidas, é solicitado ao usuário selecionar uma ou algumas das opções dadas.
Semelhante à função selectInput(), mas com uma aparência levemente diferente, e permite selecionar, por padrão, múltiplas opções.
Pede ao usuário que aperte um botão interativo para que uma certa ação seja realizada no aplicativo.
A partir de uma barra de rolagem (horizontal), o usuário é informado para selecionar um número dentro de um intervalo de valores estabelecido
Trata-se de uma função para inserção de inputs em forma de texto.
Semelhante a função tenxtInput(), com a diferença que o input informado aparecerá com tarjas (“*”)
Além das funções input citadas acima, há várias outras tais como:
Os tipos de output são definidos no primeiro objeto, a UI (interface de usuário).
Assim como os inputs, no output também exigem uma identificação - ‘outputId’.
datatable(outputId = "dataframe") # Define um dataframe como output
htmlOutput(outputId = "html") # Define um documento HTML como output
imageOutput(outputId = 'image') # Define uma imagem como output
plotOutput(outputId = 'plot') # Define um gráfico como output
tableOutput(outputId = 'tabela') # Define uma tabela como output
textOutput(outputId = 'texto') # Define um texto como output
...Feito isso, para que o(s) output(s) definido(s) seja(m) devidamente executado(s) e processado(s) pelo R, faz-se necessário também o uso das render functions (funções de renderização); por exemplo, “renderText({})”;
Estas são definidas no objeto Server.
No servidor serão executadas todas as operações desejadas:
Aqui que os labels do UI receberam suas atribuições.
As render functions (funções de renderização) são os objetos que irão efetivamente explicitar os outputs previamente definidos no UI.;
Possibilita a utilização de pacotes fora do pacote Shiny, mas que possuem suporte para renderizar seus resultados, como:
Como é na UI que alteramos as saídas do app, as alterações de layout também estarão na UI;
Basicamente, todo app vai se dividir em duas partes:
titlePanel() - título do aplicativo;
siderbarLayout() - esse recebe os comandos para posicionamentos de inputs e os espaços para os outputs.
library(shiny)
inputPanel(
titlePanel("Baby Name Explorer"),
sidebarLayout(
sidebarPanel(
textInput('name', 'Enter Name', 'David')),
mainPanel(
plotOutput('trend')))
)# Definindo a sidebar e seus parâmetros
sidebar <- dashboardSidebar(width = 300,
sidebarMenu(
id = "pages",
menuItem("Many charts", tabName = "charts",
icon = icon("chart-line")),
menuItem("Statistics", tabName = "stats",
icon = icon("file-excel"))
))
ui <- dashboardPage(header, sidebar, body)
server <- function(input, output) {
}
shinyApp(ui, server)# Adicionando subtabs na sidebar
sidebar <- dashboardSidebar(
width = 300,
sidebarMenu(
id = "pages",
menuItem("Many charts", tabName = "charts",
icon = icon("chart-line")),
menuItem("Statistics", tabName = "stats",
icon = icon("file-excel"),
menuSubItem("Team 1", tabName = "team1",
icon = icon("user")))
))
ui <- dashboardPage(header, sidebar, body)
server <- function(input, output) {
}
shinyApp(ui, server)# Adicionando inputs na sidebar
sidebar <- dashboardSidebar(width = 300,
sidebarMenu(
id = "pages",
menuItem("Many charts", tabName = "charts",
icon = icon("chart-line")),
menuItem("A couple of checkboxes",
checkboxGroupInput("checkboxes",
"Days of the week",
choices = c("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")))
))
ui <- dashboardPage(header, sidebar, body)
server <- function(input, output) {
}
shinyApp(ui, server)# Definindo a sidebar e seus parâmetros
sidebar <- dashboardSidebar(width = 300,
sidebarMenu(
id = "pages",
menuItem("Many charts", tabName = "charts",
icon = icon("chart-line")),
menuItem("Statistics", tabName = "stats",
icon = icon("file-excel"))
))
ui <- dashboardPage(header, sidebar, body)
server <- function(input, output) {
}
shinyApp(ui, server)# Adicionando subtabs na sidebar
sidebar <- dashboardSidebar(
width = 300,
sidebarMenu(
id = "pages",
menuItem("Many charts", tabName = "charts",
icon = icon("chart-line")),
menuItem("Statistics", tabName = "stats",
icon = icon("file-excel"),
menuSubItem("Team 1", tabName = "team1",
icon = icon("user")))
))
ui <- dashboardPage(header, sidebar, body)
server <- function(input, output) {
}
shinyApp(ui, server)# Adicionando inputs na sidebar
sidebar <- dashboardSidebar(width = 300,
sidebarMenu(
id = "pages",
menuItem("Many charts", tabName = "charts",
icon = icon("chart-line")),
menuItem("A couple of checkboxes",
checkboxGroupInput("checkboxes",
"Days of the week",
choices = c("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")))
))
ui <- dashboardPage(header, sidebar, body)
server <- function(input, output) {
}
shinyApp(ui, server)Resumidamente, reatividade em programação é o conceito que torna possível a interação dinâmcica do usuário com o programa, no qual o que é efetivamente executado e exibido se baseia no acompanhamento das mudanças de determinados valores. Por exemplo, se um determinado input muda, um novo cálculo deve ser executado e um novo output gerado.
A reatividade se baseia em uma paradigma diferente de programção, chamado de declarativo. No Shiny, declaramos dentro da função server() quando e quais códigos devem ser executados a depender de cada nova situação. Podemos representar as relações de dependência entre input e output e os consequentes fluxos de execução nesses casos através de um diagrama de reatividade.
exemplo:
fonte: https://programando-em-shiny.curso-r.com
# server
server <- function(input, output, session) {
output$histograma_A <- renderPlot({
print("Gerando histograma A...")
hist(mtcars[[input$variavel_A]], main = "Histograma A")
})
output$histograma_B <- renderPlot({
print("Gerando histograma B...")
hist(mtcars[[input$variavel_B]], main = "Histograma B")
})
}
# app
shinyApp(ui, server)fonte: https://programando-em-shiny.curso-r.com
fonte: https://programando-em-shiny.curso-r.com